home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / xdme_1.84_src.lha / XDME / Src / Mod / Mikro.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-29  |  16.5 KB  |  633 lines
  1. /******************************************************************************
  2.  
  3.     MODUL
  4.     mikro.c
  5.  
  6.     DESCRIPTION
  7.     hier ist alles, was zu klein war fuer einen vernuenftigen Oberbegriff
  8.  
  9.     NOTES
  10.  
  11.     BUGS
  12.  
  13.     TODO
  14.  
  15.     EXAMPLES
  16.  
  17.     SEE ALSO
  18.  
  19.     AUTHOR
  20.     Bernd "0" Noll (b_noll@informatik.uni-kl.de)
  21.  
  22.     HISTORY
  23.     ******** b_noll created
  24.     01-08-93 b_noll added MICRO_Init
  25.     26-08-93 b_noll added MICRO_Exit
  26.     07-08-94 null updated some docs
  27.     24-09-94 b_noll disabled all toggles execpt for viewmode
  28.  
  29. *!***************************************************************************
  30. *!
  31. *!  Misc Commands (Mikro.c)
  32. *!
  33. ******************************************************************************/
  34.  
  35. /**************************************
  36.         Includes
  37. **************************************/
  38. #include "defs.h"
  39. /* #include "COM.h" */
  40.  
  41.  
  42. /**************************************
  43.        Implementation
  44. **************************************/
  45.  
  46.  
  47. /*
  48. **  some commands to modify the command flow
  49. **
  50. *! >ABORT
  51. *! >UNABORT
  52. *!  they toggle a flag which controlles macro-executing
  53. *!  ABORT sets the break-flag which causes e.g. immediately macro-abortion at keys
  54. *!  or terminates line-execution
  55. *!  UNABORT allows to reset this flag in an AREXX-script,
  56. *!  is the last line produced an error, you may clear the error-flag
  57. *!  if UNABORT is the first (or only) command of a line
  58. *!
  59. *! >BREAK
  60. *! >CONTINUE
  61. *!  these two commands do nearly the same like their C-language conterparts
  62. *!  BREAK leave the current loop-construct and
  63. *!  CONTINUE goes to the next turn of the current loop-construct
  64. *!
  65. **  Note that UNABORT is obsolete since Async Rexxports are introduced,
  66. **     as after every RexxComm got in mainloop we do a clearbreaks()
  67. */
  68. /*DEFHELP #cmd program ABORT - abort the current command execution */
  69. DEFUSERCMD("abort", 0, CF_VWM|CF_ICO|CF_COK, void,do_abort, (void),)
  70. {
  71.     SETF_ABORTCOMMAND(Ep, 1);
  72. } /* do_abort */
  73.  
  74. /*DEFHELP #cmd program UNABORT - clear the ABORT flag (only in an ARexx script) */
  75. DEFUSERCMD("unabort", 0, CF_VWM|CF_ICO|CF_COK, void,do_unabort, (void),)
  76. {
  77.     SETF_ABORTCOMMAND(Ep, 0);
  78. } /* do_unabort */
  79.  
  80. /*DEFHELP #cmd program BREAK - break out of the current loop (WHILE, REPEAT) */
  81. DEFUSERCMD("break", 0, CF_VWM|CF_ICO|CF_COK, void,do_break, (void),)
  82. {
  83.     SETF_LOOPBREAK( Ep, 1 );
  84. } /* do_break */
  85.  
  86. /*DEFHELP #cmd program CONTINUE - skip to the end of the current loop (WHILE, REPEAT) */
  87. DEFUSERCMD("continue", 0, CF_VWM|CF_ICO|CF_COK, void,do_continue, (void),)
  88. {
  89.     SETF_LOOPCONT( Ep, 1 );
  90. } /* do_continue */
  91.  
  92.  
  93.  
  94.  
  95.  
  96. Prototype void clearbreaks (void);
  97. void clearbreaks (void)
  98. {
  99.     SETF_LOOPCONT( Ep, 0 );
  100.     SETF_LOOPBREAK( Ep, 0 );
  101.     SETF_ABORTCOMMAND(Ep, 0);
  102. } /* clearbreaks */
  103.  
  104.  
  105.  
  106.  
  107. /*
  108. **  some re-evaluation commands
  109. **
  110. *! >EVAL com
  111. *!
  112. *!  to split longer commandsequences to fit their length down to MAXIA
  113. *!  so MAXIA may stay "small" and anybody can avoid "expression too complex"
  114. *!
  115. *! >FORCE [T|S|F|R|D] command
  116. *!
  117. *!  That's a command that means conjunction
  118. *!  of EVAL, QUIET, UNFAIL and UNTITLE
  119. *!
  120. *!    T == unTitle
  121. *!    S == quiet (no Screen updating)
  122. *!    F == unFail
  123. *!    R == no Requestors
  124. *!    D == enable debugging mode
  125. *!     <no flags> -> simple eval
  126. *!
  127. *!  for this reason we have declared UNTITLE, QUIET and UNFAIL
  128. *!  obsolete, and have removed them;
  129. *!  most of their functionality can be accessed via macros.
  130. *!
  131. *!  >UNFAIL com
  132. *!
  133. *! That's really like EVAL, but it ignore's failures
  134. *! Very useful if U try to call an Command but U don't
  135. *! know if it is one, or if you don't want a failure to break your macro
  136. *!
  137. *!  >UNTITLE com
  138. *!
  139. *!  That's also like EVAL, except for the feature, that
  140. *!  No Title is shown during the macrocall
  141. *!
  142. *!  >QUIET com
  143. *!
  144. *! That's like EVAL, but during execution no window
  145. *! should be refreshed
  146. *! as _No_Screen_Update is increased during operation
  147. *!
  148. */
  149.  
  150. /* 25 Sep 1994; the current solution for eval/force is 12 Bytes bigger
  151.         than the previous one, but I do like it much more
  152.         no probs any more to say what is needed ... */
  153.  
  154. #define DCF_DEBUG      1
  155. #define DCF_NOTITLE    2
  156. #define DCF_NOREDRAW   4
  157. #define DCF_NOFAIL     8
  158. #define DCF_NOREQUEST 16
  159. #define DCF_max       32
  160.  
  161. static void _do_force (int flags, const char *str) {
  162.     char inter_screen  = GETF_NOSCREENUPDATE(Ep);/* control screen updates */
  163.     char inter_title   = GETF_SHOWTITLE(Ep);     /* control changes in window-titling */
  164.     char inter_request = GETF_NOREQUEST(Ep);     /* Disable flag for requestors */
  165.     char inter_debug   = GETF_DEBUG(Ep);         /* Debugging mode */
  166.     struct TextMarker chk;
  167.  
  168.     chk.ep     = Ep;
  169.     chk.line   = Ep->line;
  170.     chk.column = Ep->column;
  171.  
  172.     if (flags & DCF_NOTITLE)
  173.     SETF_SHOWTITLE(Ep, 0);
  174.     if (flags & DCF_NOREQUEST)
  175.     SETF_NOREQUEST(Ep, 1);
  176.     if (flags & DCF_DEBUG)
  177.     SETF_DEBUG(Ep, 1);
  178.     if (flags & DCF_NOREDRAW) {
  179.     SETF_NOSCREENUPDATE( Ep, 1 );
  180.     } /* if */
  181.  
  182.     buffered_do_command (str);
  183.  
  184.     if (flags & DCF_NOTITLE)
  185.     SETF_SHOWTITLE(Ep, inter_title);
  186.     if (flags & DCF_NOREQUEST)
  187.     SETF_NOREQUEST(Ep, inter_request);
  188.     if (flags & DCF_DEBUG)
  189.     SETF_DEBUG(Ep, inter_debug);
  190.     if (flags & DCF_NOFAIL) {
  191.     extern char MacroBreak;
  192.     if (MacroBreak != 1)
  193.         SETF_ABORTCOMMAND(Ep, 0);
  194. //    do_clearallbreaks();        /* simply cancel all breaks after evaluation */
  195.     } /* if */
  196.     if (flags & DCF_NOREDRAW) {
  197.     SETF_NOSCREENUPDATE( Ep, inter_screen );
  198.     if (Ep == chk.ep) {
  199.         if (Ep->line != chk.line) {
  200.         text_adjust(FALSE);
  201.         } else if (Ep->column != chk.column) {
  202.         text_adjust(FALSE);
  203. /*          } else {                */
  204. /*          text_redisplay_currline();    */
  205.         } /* if moved */
  206. /*      } else {                */
  207.     } /* if ep */
  208.     } /* if "s" */
  209. } /* _do_force */
  210.  
  211.  
  212.  
  213.  
  214. /*DEFHELP #cmd program EVAL command - reinvoke the command interpreter; that command can be used to split long commandsequenes to keep MAXIA small */
  215. DEFUSERCMD("eval", 1, CF_VWM|CF_ICO|CF_COK, void,do_eval, (void),)
  216. {
  217.     _do_force(0, av[1]);
  218. } /* do_eval */
  219.  
  220. /*DEFHELP #cmd program FORCE flags command - set special conditions for executing @{B}command@{UB};
  221. @{B}flags@{UB} can be @{B}F@{UB} ignore errorvalues, @{B}S@{UB} no screenupdates @{B}R@{UB} no errorrequesters, @{B}T@{UB} no title updates, @{B}D@{UB} activate Debug Mode */
  222. DEFUSERCMD("force", 2, CF_VWM|CF_ICO|CF_COK, void,do_force, (void),)
  223. {
  224.     char* typer = av[1];
  225.     int   flags = 0;
  226.     if (typer)                          /* check for any set flags */
  227.     while (*typer)
  228.         switch ((*(typer++))|32) {
  229.         case 't':
  230.         flags |= DCF_NOTITLE;
  231.         break;
  232.         case 's':
  233.         flags |= DCF_NOREDRAW;
  234.         break;
  235.         case 'f':
  236.         flags |= DCF_NOFAIL;
  237.         break;
  238.         case 'r':
  239.         flags |= DCF_NOREQUEST;
  240.         break;
  241.         case 'd':
  242.         flags |= DCF_DEBUG;
  243.         break;
  244.         default:
  245. DEFMESSAGE( _MIKRO_unknown_flags, "%s:\nInvalid flags '%s'" )
  246.         error (_MIKRO_unknown_flags, av[0], av[1]);
  247.         return;
  248.         } /* switch */
  249.  
  250.     _do_force (flags, av[2]);
  251.  
  252. } /* do_force */
  253.  
  254. /* the following function have been disabled; */
  255.  
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270. /*
  271. **  some write - commands
  272. **
  273. *!
  274. *! >PRINTF format parameters
  275. *!
  276. *!  create a string with format and its (up to 8) parameters
  277. *!  and write it into the current text
  278. *!
  279. *! >INSERT text
  280. *! >OVERWRITE text
  281. *!
  282. *!  insert or overwrite text in the current text without respect
  283. *!  to the specialflag INSERTMODE
  284. *!
  285. */
  286.  
  287. Prototype void m_write (char *);
  288. void m_write (char *string)
  289. {
  290.     char c;
  291.     char * ptr    = string;
  292.     char * pptr;
  293.  
  294. /*    char quoted = GETF_AUTOINDENT(Ep); */
  295. /*    SETF_AUTOINDENT(Ep, 0);            */
  296.     while ((c = *ptr)) {
  297.     pptr = ptr;
  298.     while ((c != 0) &&
  299.         (c != '\t' && c != ('t'&31)) &&
  300.         (c != '\n' && c != ('n'&31)) &&
  301.         (c != '\r' && c != ('r'&31))) {
  302.         ++ptr;
  303.         c = *(ptr);
  304.     } /* while */
  305.     *ptr = 0;
  306. /* printf ("< '%s'\n", pptr); */
  307.     text_write(pptr);
  308.     if (c != 0) {
  309.         *ptr = c;
  310.         ++ptr;
  311.         switch (c) {
  312.         case '\t':
  313.         case 't'&31:
  314.         do_tab();       /* do_command ("tab"); */
  315.         /* !! might be better to create some spaces !! */
  316.         break;
  317.         case '\n':
  318.         case 'n'&31:
  319.         do_split();
  320.         do_firstcolumn();
  321.         do_down();      /*  do_command ("split first down"); OR do_command ("return first"); */
  322.         break;
  323.         case '\r':
  324.         case 'r'&31:
  325.         av[0] = "b";
  326.         do_bs();        /* do_command ("bs"); */
  327.         break;
  328.         /* default: */ /* !! oh yea - I know that there are others C-escapes, but these were thought to be important !! */
  329.         } /* switch */
  330.     } /* if */
  331.     } /* while */
  332. /*    SETF_AUTOINDENT(Ep, quoted); */
  333. } /* m_write */
  334.  
  335.  
  336. /*DEFHELP #cmd textedit OVERWRITE text - overwrite text at the current position ignoring $INSERTMODE */
  337. DEFUSERCMD("overwrite", 1, CF_COK, void,do_insertwrite, (void),;)
  338.  
  339. /*DEFHELP #cmd textedit INSERT text - insert some text at the current position ignoring $INSERTMODE */
  340. DEFUSERCMD("insert", 1, CF_COK, void,do_insertwrite, (void),)
  341. {
  342.     char insertbackup = GETF_INSERTMODE(Ep);
  343.  
  344.     if (av[0][0] != 'w')
  345.     SETF_INSERTMODE(Ep, (av[0][0] == 'i'));
  346.  
  347.     m_write(av[1]);
  348.  
  349.     SETF_INSERTMODE(Ep, insertbackup);
  350. } /* do_insertwrite */
  351.  
  352.  
  353. /*DEFHELP #cmd textedit PRINTF format parameters - create a string with printf-style @{B}format@{UB} and its (up to 8) @{B}parameters@{UB} and write it into the current text */
  354. DEFUSERCMD("printf", 2, CF_COK, void,do_printf, (void),)
  355. {
  356.     char* iav = av[0];
  357.     char* arg [10];
  358.     char* aux [10];
  359.     char* ptr = av[2];
  360.     char quoted;
  361.     ULONG arc;
  362.     char* buf;
  363.  
  364.     if (!(buf = malloc(512))) {
  365.     nomemory();
  366.     abort2();
  367.     } /* if */
  368.  
  369.     for (arc = 0; arc < 10; ++arc) arg[arc] = NULL;
  370.     arc = 0;
  371.     while ((arg[arc] = breakout (&ptr, "ed, &aux[arc]))) {
  372. /* printf (">arg %ld == %s\n", arc, arg[arc]); */
  373.     if (++arc >= 10)
  374.         break;
  375.     } /* while */
  376.  
  377.     vsprintf (buf, av[1], (va_list)arg);
  378.     m_write (buf);
  379.  
  380.     while (arc > 0) {
  381.     --arc;
  382.     if (aux[arc])
  383.         free(aux[arc]);
  384.     } /* while */
  385.  
  386.     av[0] = iav;
  387.     free (buf);
  388. } /* do_printf */
  389.  
  390.  
  391.  
  392.  
  393. /*
  394. **  Redefine these names to adjust the used buffers to Your settings
  395. **  the commands are 'atomic' so there should be no interference to
  396. **  other 'atomic' commands using them.
  397. **
  398. **  for XDME changed buffers[0]/buffers[1] to tmp_buffer/tmp_buf2
  399. */
  400. #define firstbuffer  tmp_buffer
  401.  
  402.  
  403.  
  404.  
  405. /*
  406. * !  $[SPC.]currentword
  407. * !     that read-only special-variable
  408. * !     represents "the word under the cursor"
  409. * !     that means it finds the beginning of the current word on
  410. * !     on its own (but we do not move the cursor) if cursor is
  411. * !     not within a word, it returns the next word of the line
  412. * !     if there is no next word, an empty string is returned
  413. * !  NOTE this variable is not accessible, if PATCH_VARS is not active
  414. * !
  415. **  current_word           (uses firstbuffer)
  416. **
  417. **  Returns the word under the cursor,
  418. **  is used by fastscan and should be used by ref and tag instead of
  419. **  their own functions
  420. */
  421.  
  422. #define IS_VALID_CHAR(ch)     (isalnum((ch)) || (ch) == '_')
  423.  
  424. Prototype char *current_word (void);
  425. char *current_word (void) {
  426.     char *str;
  427.     int   i, j = 0;
  428.  
  429.     str = (char *)firstbuffer;
  430.  
  431.     i = Ep->column;
  432.     while ((i > 0)      &&  IS_VALID_CHAR(Current[i])) --i; /*  goto beginning of word */
  433.     while ((Current[i]) && !IS_VALID_CHAR(Current[i])) ++i; /* skip spaces and other garbage */
  434.  
  435.     while (IS_VALID_CHAR(Current[i]) && (j <= LINE_LENGTH)) /* copy "word" into buffer */
  436.     str[j++] = Current[i++];
  437.  
  438.     str[j] = 0;
  439.  
  440.     return str;
  441. } /* current_word */
  442.  
  443. Prototype char *recent_word (void);
  444. char *recent_word (void) {
  445.     char *str;
  446.     int   i, j = 0;
  447.  
  448.     str = (char *)firstbuffer;
  449.     i = Ep->column;
  450.  
  451.     while ((i >= 0) && !IS_VALID_CHAR(Current[i])) --i; /* skip spaces and other garbage */
  452.     while ((i >= 0) &&  IS_VALID_CHAR(Current[i])) --i; /* goto beginning of word */
  453.  
  454.     i ++;
  455.     while (IS_VALID_CHAR(Current[i]) && (j <= LINE_LENGTH)) /* copy "word" into buffer */
  456.     str[j++] = Current[i++];
  457.  
  458.     str[j] = 0;
  459.     return str;
  460. } /* recent_word */
  461.  
  462.  
  463.  
  464.  
  465. /*
  466. **  some flags
  467. **  The following commands should be placed into prefs.c
  468. **
  469. *!
  470. *!  Viewmode
  471. *!    That flag disables modifications of the current
  472. *!    text; if TRUE any modifiing command causes an error
  473. *!    (modifiing commands are recognized in do_command with the
  474. *!    flag CF_VWM being FALSE)
  475. *!
  476. *!  ActivateToFront
  477. *!  Windowcycling
  478. *!    These two flags refer to SELECT:
  479. *!
  480. *!    ActivateToFront invokes a "WindowToFront()" every
  481. *!            time, windows are switched
  482. *!    Windowcycling    enables the possibility to switch
  483. *!            to the other end of Textlist, if
  484. *!            one end is reacjed with SELECT next/prev
  485. *!
  486. *!  SourceBreaks
  487. *!    That flag refers to SOURCE
  488. *!    if TRUE if an Abortcommand or a Break occurs
  489. *!    on sourcing level, the operation is aborted
  490. *!    else the next line is executed.
  491. *!
  492. *!  SimpleTabs
  493. *!    That flag is an add to SAVETABS and SAVE[old|as]
  494. *!    if Savetabs is set, SimpleTabs decides to use
  495. *!    TAB-Optimisation until the first non-blank only
  496. *!    (is usable, if a program ignores leading whitespace,
  497. *!    but does not convert tabs to spaces)
  498. *!
  499. *!  FWOvr (Fixed Width Overwrite)
  500. *!    That flag is used in connection with INSERTMODE:
  501. *!    if the User has selected Overwrite, and that flag is
  502. *!    TRUE, DEL will cause replacing the deleted char
  503. *!    by a space instead of shortening the line and
  504. *!    BS is replaced by a simple LEFT (perhaps with writing
  505. *!    a space)
  506. *!
  507. *!  TextLine/LongLine (14-06-93)
  508. *!    this flag is used to disable movement left of the end
  509. *!    of the current line; note: ending spaces are usually
  510. *!    ignored in that mode
  511. *!    (this option was done to satisfy a CED user; dunno if it helps)
  512. *!
  513. */
  514.  
  515.  
  516. DEFUSERCMD("viewmode", 1, CF_VWM|CF_COK|CF_ICO, void,do_viewmode, (void),)
  517. {
  518.     SETF_VIEWMODE(Ep, test_arg(av[1], GETF_VIEWMODE(Ep)));
  519. DEFMESSAGE( _MIKRO_viewmode_txt, "Viewmode %s" )
  520.     title (_MIKRO_viewmode_txt,
  521.     (GETF_VIEWMODE(Ep))? __on: __off);
  522. } /* do_viewmode */
  523.  
  524.  
  525.  
  526.  
  527. /***************************************
  528.     The following functions are
  529.     disabled ...
  530.     they are not used any more or they
  531.     are replaced w/ macros
  532. ***************************************/
  533.  
  534. /* int is_aborted (void) {
  535.     return (GETF_ABORTCOMMAND(Ep));
  536. } /* is_aborted */
  537.  
  538. /* Prototype void clearcont (void);
  539. void clearcont (void)  {
  540.     SETF_LOOPCONT( Ep, 0 );
  541. } /* clearcont */
  542.  
  543. /* Prototype void clearbreak (void);
  544. void clearbreak (void) {
  545.     SETF_LOOPBREAK( Ep, 0 );
  546. } /* clearbreak */
  547.  
  548.  
  549. /* DEFHELP #cmd misc UNFAIL command - short for "FORCE F command" */
  550. /* DEFUSERCMD("unfail", 1, CF_VWM|CF_ICO|CF_COK, void, do_unfail, (void),)
  551. {
  552.     _do_force(DCF_NOFAIL, av[1]);
  553. } /* do_unfail */
  554.  
  555. /* DEFHELP #cmd misc UNTITLE command - short for "FORCE T command" */
  556. /* DEFUSERCMD("untitle", 1, CF_VWM|CF_ICO|CF_COK, void,do_untitle, (void),)
  557. {
  558.     _do_force(DCF_NOTITLE, av[1]);
  559. } /* do_untitle  */
  560.  
  561. /* DEFHELP #cmd misc QUIET command - short for "FORCE S command" */
  562. /* DEFUSERCMD("quiet", 1, CF_VWM|CF_ICO|CF_COK, void,do_quiet, (void),)
  563. {
  564.     _do_force(DCF_NOREDRAW, av[1]);
  565. } /* do_quiet */
  566.  
  567. /***************************************
  568.     The following toggle commands are
  569.     disabled in this module; this had
  570.     several reasons:
  571.      * they do belong into "prefs.c".
  572.      * all of them are accessible via
  573.        the variable interface.
  574.      * some of them are not supported
  575.        by "xdme" any more.
  576. ***************************************/
  577.  
  578. /*Prototype  void do_activefront (void);
  579. void do_activefront (void) {
  580.     SETF_ACTIVATETOFRONT(Ep, test_arg (av[1], GETF_ACTIVATETOFRONT(Ep)));
  581.     title ("Activated Windows are %smoved front now",
  582.         (GETF_ACTIVATETOFRONT(Ep))? "": "NOT ");
  583. } /* do_activefront */
  584.  
  585. /*Prototype  void do_windowcyc (void);
  586. void do_windowcyc (void) {
  587.     SETF_WINDOWCYCLING(Ep, test_arg (av[1], GETF_WINDOWCYCLING(Ep)));
  588.     title ("Windowcycling is now %s",
  589.         (GETF_WINDOWCYCLING(Ep))? "ON: "OFF");
  590. } /* do_windowcyc */
  591.  
  592. /*Prototype  void do_sourcebreak (void);
  593. void do_sourcebreak (void) {
  594.     SETF_SOURCEBREAKS(Ep, test_arg (av[1], GETF_SOURCEBREAKS(Ep)));
  595.     title ("Source - Breaks are %s",
  596.         (GETF_SOURCEBREAKS(Ep)) "Enabled": "Ignored");
  597. } /* do_sourcebreak */
  598.  
  599. /*Prototype  void do_simpletabs (void);
  600. void do_simpletabs (void) {
  601.     SETF_SIMPLETABS(Ep, test_arg (av[1], GETF_SIMPLETABS(Ep)));
  602.     title ("Tabsaving %s",
  603.     (!GETF_SAVETABS(Ep))? "OFF":
  604.         (GETF_SIMPLETABS(Ep))? "up to firstnb": "FULL");
  605. } /* do_simpletabs */
  606.  
  607. /*Prototype  void do_fwovr (void);
  608. void do_fwovr (void) {
  609.     SETF_FWOVR(Ep, test_arg (av[1], GETF_FWOVR(Ep)));
  610.     title ("Overwrite Delete FixWidth is now %s",
  611.         (GETF_FWOVR(Ep))? "ON": "OFF");
  612. } /* do_fwovr */
  613.  
  614. /* Prototype void do_shortline (void);
  615. void do_shortline (void) {
  616.     SETF_SLINE(Ep, test_arg (av[1], GETF_SLINE(Ep)));
  617.     title ("Movement after EoL is now %s",
  618.         (!GETF_SLINE(Ep))  "ENABLED": "DISABLED");
  619. } /* do_longline */
  620.  
  621.  
  622. #ifdef STATIC_COM
  623.  
  624.     DEFFLAG( 94-10-05, LoopCont,  0 )
  625.     DEFFLAG( 94-10-05, LoopBreak, 0 )
  626.     DEFFLAG( 94-10-05, KillBlock, 0 )
  627.  
  628. #endif
  629.  
  630. /******************************************************************************
  631. *****  ENDE mikro.c
  632. ******************************************************************************/
  633.